home *** CD-ROM | disk | FTP | other *** search
/ CD ROM Paradise Collection 4 / CD ROM Paradise Collection 4 1995 Nov.iso / clang / mempool.zip / MEMPOOL.CPP < prev    next >
C/C++ Source or Header  |  1994-02-10  |  3KB  |  158 lines
  1. // listing 2.
  2.  
  3. #include "mempool.h"
  4.  
  5. MemoryPoolLink::
  6.   MemoryPoolLink(
  7.     size_t size,
  8.     MemoryPoolLink *_next)
  9.   : bits(0l),
  10.     data(new 
  11.       char[size*PoolSize]),
  12.     next(_next)
  13. {
  14.   ;
  15. }
  16.  
  17. MemoryPoolLink::
  18.   ~MemoryPoolLink()
  19. {
  20.   delete[] data;
  21. }
  22.     
  23. void *MemoryPoolLink::malloc(
  24.   size_t size)
  25. {
  26. static char lookup[] = {
  27.   0,     1,     0,     2,
  28.   0,     1,     0,     3,
  29.   0,     1,     0,     2,
  30.   0,     1,     0,     4,
  31.   };
  32.   int shift = 0;
  33.   unsigned long b = bits;
  34.   if((b&0xFFFF) == 0xFFFF)
  35.   {
  36.     shift = 16;
  37.     b >>= 16;
  38.   }
  39.   if((b&0xFF) == 0xFF)
  40.   {
  41.     shift += 8;
  42.     b >>= 8;
  43.   }
  44.   if((b&0xF) == 0xF)
  45.   {
  46.     shift += 4;
  47.     b >>= 4;
  48.   }
  49.   shift += lookup[b&0xF];
  50.   bits |= (1l << shift);
  51.   return data + 
  52.     (shift * size);
  53. }
  54.  
  55. void MemoryPoolLink::free(
  56.   void *ptr, 
  57.   size_t size)
  58. {
  59.   bits &= 
  60.     ~(1l << 
  61.     ((char *)ptr-data)/size);
  62. }
  63.  
  64. MemoryPool::MemoryPool(
  65.   size_t _size)
  66.   : size(_size),
  67.     freeHead(0,NULL),
  68.     usedHead(0,NULL)
  69. {
  70. }
  71.  
  72. void *MemoryPool::add()
  73. {
  74.   MemoryPoolLink *temp = new 
  75.     MemoryPoolLink(size,
  76.     freeHead.next);
  77.   if(temp == NULL)
  78.     return NULL;
  79.   freeHead.next = temp;
  80.   return 
  81.     freeHead.next->
  82.     malloc(size);
  83. }
  84.  
  85. void *MemoryPool::malloc()
  86. {
  87.   if(freeHead.next)
  88.   {
  89.     void *ret = 
  90.       freeHead.next->
  91.       malloc(size);
  92.     if(freeHead.next->bits ==
  93.       0xFFFFFFFFL)
  94.     {
  95.       MemoryPoolLink *temp = 
  96.         freeHead.next;
  97.       freeHead.next = 
  98.         temp->next;
  99.       temp->next = 
  100.         usedHead.next;
  101.       usedHead.next = temp;
  102.     }
  103.     return ret;
  104.   }
  105.   return add();
  106. }
  107.  
  108. void MemoryPool::free(
  109.   void *ptr)
  110. {
  111.   MemoryPoolLink *temp = 
  112.     freeHead.next;
  113.   MemoryPoolLink *prev = 
  114.     &freeHead;
  115.   while(temp)
  116.   {
  117.     ptrdiff_t diff = 
  118.       temp->data - 
  119.       (char *)ptr;
  120.     if(diff > 0 && 
  121.       diff < size*PoolSize)
  122.     {
  123.       temp->free(ptr, size);
  124.       if(temp->bits == 0l)
  125.       {
  126.         prev->next = 
  127.           temp->next;
  128.         delete temp;
  129.       }
  130.       return;
  131.     }
  132.     prev = temp;
  133.     temp = temp->next;
  134.   }
  135.   temp = usedHead.next;
  136.   prev = &usedHead;
  137.   while(temp)
  138.   {
  139.     ptrdiff_t diff = 
  140.       temp->data - 
  141.       (char *)ptr;
  142.     if(diff > 0 && 
  143.       diff < size*PoolSize)
  144.     {
  145.       temp->free(ptr, size);
  146.       prev->next = 
  147.         temp->next;
  148.       temp->next = 
  149.         freeHead.next;
  150.       freeHead.next = 
  151.         temp;
  152.       return;
  153.     }
  154.     prev = temp;
  155.     temp = temp->next;
  156.   }
  157. }
  158.